/*
 * 文 件 名:  StringUtil.java
 * 版    权:  Isoftstone Technologies Co., Ltd. Copyright 2010,  All rights reserved
 * 描    述:  字符串工具类
 * 修 改 人:  yuma
 * 修改时间:  Aug 9, 2010
 * 跟踪单号:  <跟踪单号>
 * 修改单号:  <修改单号>
 * 修改内容:  <修改内容>
 */
package com.iss.umservice.common;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.apache.log4j.Logger;


/**
 * 
 * <p>
 * [功能简述] 字符串工具类
 * <p>
 * <p>
 * [详细描述] 字符串工具类
 * </p>
 * 
 * @author yuma
 * @version [GZT 1.00, Aug 9, 2010]
 * @see [相关类/方法]
 * @since [GZT]
 */
public class StringUtil
{
    /** 日志对象 */
    private static final Logger log = Logger.getLogger(StringUtil.class);
    
    /**
     * 私有构造函数
     */
    private StringUtil()
    {
    }
    
    /**
     * getLength 返回字符串的长度
     * 
     * @param src 输入字符串
     * @return int 字符串长度
     * 
     */
    public static int getLength(final String src)
    {
        return ((null == src) || ("".equals(src))) ? 0 : src.getBytes().length;
    }
    
    /**
     * getLength 返回非空字符串
     * 
     * @param obj 输入对象
     * @return string
     * 
     */
    public static String nvl(final Object obj)
    {
        return (null == obj) ? "" : obj.toString().trim();
    }
    
    /**
     * String to float
     * 
     * @param str String
     * @param def float number.
     * @return [参数说明]
     * 
     * @see [类、类#方法、类#成员]
     */
    public static float toFloat(final String str, final float def)
    {
        float flat = def;
        
        try
        {
            flat = Float.parseFloat(str);
        }
        catch (Exception e)
        {
            flat = def;
        }
        return flat;
    }
    
    /**
     * String to int <功能详细描述>
     * 
     * @param str String
     * @param def int number.
     * @return [参数说明]
     * @see [类、类#方法、类#成员]
     */
    public static int toInt(final String str, final int def)
    {
        int value = def;
        
        try
        {
            value = Integer.parseInt(str);
        }
        catch (Exception e)
        {
            value = def;
        }
        
        return value;
    }
    
    /**
     * 将字符串转换成日期形 参数：time，String，日期字符串 pattern, String, 解析的格式 返回：Date，日期形
     * 
     * @param time String time.
     * @param pattern pattern
     * @return Date
     * @see [类、类#方法、类#成员]
     */
    public static Date timeStr2Date(final String time, final String pattern)
    {
        SimpleDateFormat sdf;
        Date date = null;
        if (isEmpty(time) || isEmpty(pattern))
        {
            return null;
        }
        sdf = new SimpleDateFormat(pattern, new Locale("EN"));
        
        try
        {
            date = sdf.parse(time);
        }
        catch (ParseException e)
        {
            log.error(e.toString());
        }
        return date;
    }
    
    /**
     * 将日期型转换成字符串 参数：time，Date pattern, String, 转换的目标格式
     * 
     * @param time Date time
     * @param pattern pattern.
     * @return String
     * @see [类、类#方法、类#成员]
     */
    public static String date2TimeStr(final Date time, final String pattern)
    {
        SimpleDateFormat sdf;
        if (null == pattern)
        {
            throw new IllegalArgumentException(
                    "pattern parameter can not be null");
        }
        if (null == time)
        {
            throw new IllegalArgumentException("time parameter can not be null");
        }
        sdf = new SimpleDateFormat(pattern, new Locale("EN"));
        return sdf.format(time);
    }
    
    /**
     * 如果一个字符串没有给定值或为空，则给定一个默认值
     * 
     * @param str String
     * @param def String
     * @return string
     * @see [类、类#方法、类#成员]
     */
    public static String asDefault(final String str, final String def)
    {
        String resultStr = "";
        if ((str == null) || "".equals(str.trim()))
        {
            resultStr = def;
        }
        else
        {
            resultStr = str;
        }
        return resultStr;
    }
    
    /**
     * 允许null对象的trim方法
     * 
     * @param str String.
     * @return [参数说明]
     */
    public static String trim(final String str)
    {
        return str == null ? null : str.trim();
    }
    
    /**
     * 判断字符串是否为null对象或是空白字符
     * 
     * @param str String.
     * @return boolean.
     * @see [类、类#方法、类#成员]
     */
    public static boolean isEmpty(final String str)
    {
        boolean result;
        if ((str == null) || "".equals(str))
        {
            result = true;
        }
        else
        {
            result = false;
        }
        return result;
    }
    
    /**
     * <p>
     * [功能简述] 判断字符串数据是否为空
     * <p>
     * <p>
     * [详细描述] 数组对象为空或者里面都是空字符串时则认为是空
     * </p>
     * 
     * @param str
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static boolean isEmpty(String[] str)
    {
        if (str == null)
        {
            return true;
        }
        boolean result = true;
        for (String s : str)
        {
            if (!isEmpty(s))
            {
                result = false;
                break;
            }
        }
        return result;
    }
    
    /**
     * <p>
     * [功能简述] 检查字符串是否超过一定的长度
     * <p>
     * <p>
     * [详细描述] 检查字符串是否超过一定的长度，如果超过了则加上...符号
     * </p>
     * 
     * @param str
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String checkStringLen(final String str, final int checkLen)
    {
        if (isEmpty(str))
        {
            return "";
        }
        if (str.length() > checkLen)
        {
            return addPoint(str.substring(0, checkLen));
        }
        return str;
    }
    
    /**
     * 给传入的字符串加上...符号
     * 
     * @param str String
     * @return string
     * @see [类、类#方法、类#成员]
     */
    public static String addPoint(final String str)
    {
        return str + "...";
    }
    
    /**
     * 
     * <p>
     * [功能简述]给xml字符串加根标签
     * <p>
     * <p>
     * [详细描述]给xml字符串加根标签
     * </p>
     * 
     * @param str
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String addRootTag(String str)
    {
        // modify Jjdong
        if (null == str)
        {
            return "";
        }
        
        return "<root>" + str.trim() + "</root>";
    }
    
    /**
     * 
     * <p>
     * [功能简述] 过滤页面输入非法字符
     * <p>
     * <p>
     * [详细描述] 过滤页面输入非法字符(包括html特殊字符) 如果为"",转化成null，用于条件查询时默认的所有查询
     * </p>
     * 
     * @param s
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String filterHTMLinput(String s)
    {
        if (s != null)
        {
            s = s.trim();// 去除左右空格
            s = StringUtil.filterHTMLinput2(s);
            
        }
        if ("".equals(s))
        {
            s = null;
        }
        return s;
    }
    
    public static String filterHTMLinput2(String s)
    {
        if (s != null)
        {
            // 过滤html特殊字符为html实体
            s = s.replaceAll("&", "&amp;")
                    .replaceAll("<", "&lt;")
                    .replaceAll(">", "&gt;")
                    .replaceAll("\"", "&quot;");
        }
        
        return s;
    }
    
    /**
     * 
     * <p>
     * [功能简述] 转义aracle特殊字符
     * <p>
     * <p>
     * [详细描述] 转义aracle特殊字符
     * </p>
     * 
     * @param s 字符串
     * @return String
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String escapeOracleSpecialChar(String specialString)
    {
        if (null == specialString || "".equals(specialString.trim()))
        {
            return specialString;
        }
        
        specialString = specialString.replaceAll("\\_", "\\\\_")
                .replaceAll("\\%", "\\\\%")
                .replaceAll("\\&", "\\\\&");
        return specialString;
    }
    
    /**
     * 
     * <p>
     * [功能简述]将字符串按参数匹配
     * <p>
     * <p>
     * [详细描述]将字符串按参数中的{}匹配为对应的参数
     * </p>
     * 
     * @param matchString 匹配字符串
     * @param args 参数对象
     * @return String
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String matchStringParameter(String matchString, Object[] args)
    {
        if (null == matchString || "".equals(matchString.trim()))
        {
            return matchString;
        }
        
        if (matchString.indexOf("{}") == -1)
        {
            return matchString;
        }
        
        String[] matchStrings = matchString.split("\\{\\}");
        StringBuffer sb = new StringBuffer();
        if (null == args || args.length == 0)
        {
            for (int i = 0; i < matchStrings.length; i++)
            {
                sb.append(matchStrings[i]);
            }
            
            return sb.toString();
        }
        else if (args.length >= matchStrings.length)
        {
            for (int i = 0; i < matchStrings.length; i++)
            {
                sb.append(matchStrings[i]);
                sb.append(args[i]);
            }
            return sb.toString();
        }
        else
        {
            for (int i = 0; i < matchStrings.length; i++)
            {
                if (i < args.length)
                {
                    sb.append(matchStrings[i]);
                    sb.append(args[i]);
                }
                else
                {
                    sb.append(matchStrings[i]);
                }
            }
            return sb.toString();
        }
    }
    
    /**
     * add Jjdong
     * <p>
     * [功能简述]将字符串转成16进制
     * <p>
     * <p>
     * [详细描述]将字符串转成16进制
     * </p>
     * 
     * @param str
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String str2HexStr(String str)
    {
        char[] chars = "0123456789abcdef".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;
        for (int i = 0; i < bs.length; i++)
        {
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = bs[i] & 0x0f;
            sb.append(chars[bit]);
        }
        
        return sb.toString();
    }
    
    /**
     * add Jjdong
     * <p>
     * [功能简述]将16进制转成字符串
     * <p>
     * <p>
     * [详细描述]将16进制转成字符串
     * </p>
     * 
     * @param hexStr
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String hexStr2Str(String hexStr)
    {
        String str = "0123456789abcdef";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++)
        {
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte)(n & 0xff);
        }
        return new String(bytes);
    }
    
    /**
     * 
     * <p>
     * [功能简述]将unicode编码格式转成 utf8 编码 同时按照16进制编码输出
     * <p>
     * <p>
     * [详细描述]客户端请求使用，字节数组进行16进制编码。
     * </p>
     * 
     * @param param
     * @return [参数说明]
     * @throws UnsupportedEncodingException
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String uni2utf8(String param)
            throws UnsupportedEncodingException
    {
        byte[] bytes = param.getBytes("UTF-8");
        
        return new String(Hex.encodeHex(bytes));
    }
    
    /**
     * <p>
     * [功能简述]将 utf8 编码格式转成 unicode 编码 同时按照16进制解码输出
     * <p>
     * <p>
     * [详细描述]服务端响应使用，字节数组进行16进制解码。
     * </p>
     * 
     * @param params
     * @return [参数说明]
     * @throws UnsupportedEncodingException
     * @throws DecoderException
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String utf82uni(String param)
            throws UnsupportedEncodingException, DecoderException
    {
        byte[] bytes = Hex.decodeHex(param.toCharArray());
        
        return new String(bytes, "UTF-8");
    }
    
    /**
     * 
     * <p>
     * [功能简述] 根据传入的分隔符将字符串分成字符串集合
     * <p>
     * <p>
     * [详细描述] 根据传入的分隔符将字符串分成字符串集合
     *          例如splitString("1,2,3"，","),得到list{1,2,3};
     * </p>
     * @param str
     * @param separator
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static List<String> splitString(String str, String separator)
    {
        List<String> list = new ArrayList<String>();
        if (!isEmpty(str))
        {
            try
            {
                String[] strs = str.split(separator);
                for (String string : strs)
                {   
                    if(!isEmpty(str))
                    {
                        list.add(string);
                    }
                }
            }
            catch (Exception e)
            {
                log.error(e.toString());
            }
        }
        return list;
    }
    
    /**
     * 
     * <p>
     * [功能简述]生成接受上行短信和接受状态报告的jsp页面
     * <p>
     * <p>
     * [详细描述]
     * </p>
     * 
     * @param args [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    
    public static void buildFile(String readFile, String writerFile,
            String passageId)
    {
        InputStreamReader fr = null;
        BufferedReader br = null;
        FileWriter fw = null;
        BufferedWriter bw = null;
        try
        {
            fr = new InputStreamReader(new FileInputStream(readFile), "utf-8");
            br = new BufferedReader(fr);
            fw = new FileWriter(writerFile);
            bw = new BufferedWriter(fw);
            String str = br.readLine();
            String sOld = "String passageId = \"1\";";
            String sNew = "String passageId = \"" + passageId + "\";";
            while (null != str)
            {
                if (str.contains(sOld))
                {
                    str = str.replaceAll(sOld, sNew);
                }
                bw.write(str);
                bw.newLine();
                str = br.readLine();
            }
            bw.flush();
            br.close();
            bw.close();
        }
        catch (FileNotFoundException e)
        {
            log.error(e.toString());
        }
        catch (IOException e)
        {
            log.error(e.toString());
        }
        finally
        {
            try
            {
                br.close();
                bw.close();
            }
            catch (IOException e)
            {
                log.error(e.toString());
            }
        }
        
    }
    
    /**
     * 
     * <p>
     * [功能简述] 替换oralce替代变量&字符
     * <p>
     * <p>
     * [详细描述]针对模糊查询字段，替换oralce替代变量&字符
     * </p>
     * @param sqlStr
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String replaceSQL(String paraneterStr)
    {
        String paramter = "";
        if (isEmpty(paraneterStr))
        {
            return paramter;
        }
        paramter = paraneterStr.replaceAll("&", "'||chr(38)||'");
        
        return paramter;
    }
    
    /**
     * 
     * <p>
     * [功能简述]获取11位的手机号
     * <p>
     * <p>
     * [详细描述]
     * </p>
     * @param phone
     * @return [参数说明]
     * @exception throws [违例类型] [违例说明]
     * @see [类、类#方法、类#成员]
     */
    public static String getFormartPhone(String phone)
    {
        
        if (!StringUtil.isEmpty(phone) && phone.length() > 11)
        {
            phone = phone.substring(phone.length() - 11, phone.length());
        }
        
        return phone; 
    }
    
    
    public static void main(String[] args) throws  Exception
    {   
//        String s = "a__b";
//        String ss = "a&b%";
//        System.out.println(StringUtil.escapeOracleSpecialChar(s));
//        System.out.println(StringUtil.escapeOracleSpecialChar(ss));
//        
//        String matchString = "hello:{},ccd:{},dd:{}";
//        System.out.println(StringUtil.matchStringParameter(matchString,
//               new String[] {"bibber", "abc"}));
//        
//        System.out.println(StringUtil.str2HexStr("<CheckResult>1</CheckResult>"));
//        
//        System.out.println(StringUtil.hexStr2Str("3c436865636b526573756c743e313c2f436865636b526573756c743e"));
//        
//        String ss22 = "世界和平";
//        
//        String sss333 = uni2utf8(ss22);
//        
//        System.out.println(sss333);
//        
//        System.out.println(utf82uni(sss333));
        System.out.println(StringUtil.getFormartPhone("8615896458375xx"));
        
                
    }
}